home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 21 / AMIGAplus Sonderheft 21 (1999)(ICP)(DE)[!].iso / PublicDomain / System / recoverdeldir / c / DeviceInfo.c < prev    next >
C/C++ Source or Header  |  1999-08-23  |  5KB  |  225 lines
  1. #include <dos/dos.h>
  2. #include <dos/dosextens.h>
  3. #include <dos/filehandler.h>
  4. #include <exec/memory.h>
  5. #include <utility/tagitem.h>
  6.  
  7. #include <clib/dos_protos.h>
  8. #include <clib/exec_protos.h>
  9.  
  10. #include <pragmas/dos_pragmas.h>
  11. #include <pragmas/exec_pragmas.h>
  12.  
  13. #include <string.h>
  14.  
  15. #define TOBADDR(x) (((ULONG)(x)) >> 2)
  16.  
  17. // Dieses Programm kann resident gemacht werden
  18.  
  19. long __saveds progstart (void)
  20. {
  21.     struct ExecBase   *SysBase;
  22.     struct DosLibrary *DOSBase;
  23.  
  24.     const char     VersionString[] = {"\0$VER: DeviceInfo 1.3 " __AMIGADATE__" ©1999 Thomas Krafzik\r\n"};
  25.     UBYTE          template[]      = "DEVICE/A,TYPE/S,NAME/S\n";
  26.     LONG           error           = RETURN_OK;
  27.     struct         {
  28.                    char *dev;
  29.                    LONG type;
  30.                    LONG name;
  31.                }
  32.                arg             = {NULL};
  33.     struct RDArgs *rdargs;
  34.  
  35.     // Zuerst SysBase, sonst geht alles schief
  36.     SysBase = * (struct ExecBase **) 4L;
  37.  
  38.     if (DOSBase = (struct DosLibrary *) OpenLibrary (DOSNAME, 37L))
  39.     {
  40.         if (rdargs = ReadArgs (template, (LONG *) &arg, 0))
  41.         {
  42.             struct FileSysStartupMsg *fssm;
  43.             struct DosEnvec          *de;
  44.             struct DosList           *dol;
  45.             char                     *temp_devname;
  46.             UBYTE                    *devname;
  47.             ULONG                     dostype;
  48.             ULONG                     dostype_bool = FALSE;
  49.             ULONG                     try_the_other_way = FALSE;
  50.  
  51.             // ------···--------------------···
  52.             // ---···--- FilesystemID ---···---
  53.             // ···--------------------···------
  54.  
  55.             // eventuell eingegebenen Doppelpunkt eliminieren
  56.             // in der DosList sind die Geräte nur ohne Doppelpunkt anzutreffen
  57.             if (devname = AllocVec (strlen (arg . dev) + 1, MEMF_CLEAR))
  58.             {
  59.                 strcpy (devname, arg . dev);
  60.  
  61.                 temp_devname = devname;
  62.  
  63.                 while (*temp_devname)
  64.                 {
  65.                     if (*temp_devname == ':')
  66.                     {
  67.                         // Doppelpunkt gefunden, eliminieren
  68.                         *temp_devname = 0;
  69.                         break;
  70.                     }
  71.                     temp_devname++;
  72.                 }
  73.  
  74.                 // DosList vorbereiten
  75.                 dol = LockDosList (LDF_DEVICES | LDF_READ);
  76.  
  77.                 // Gerät vorhanden ?
  78.                 // LDF_READ muß hier nicht mehr angegeben werden
  79.                 if (dol = FindDosEntry (dol, devname, LDF_DEVICES))
  80.                 {
  81.                     // FileSysStartupMsg vorhanden ?
  82.                     fssm = BADDR (dol -> dol_misc . dol_handler . dol_Startup);
  83.  
  84.                     // Ist der Speicher an der Stelle gültig ?
  85.                     if (TypeOfMem (fssm))
  86.                     {
  87.                         // DosEnvec vorhanden ?
  88.                         de = BADDR (fssm -> fssm_Environ);
  89.  
  90.                         // Ist der Speicher an der Stelle gültig ?
  91.                         if (TypeOfMem (de))
  92.                         {
  93.                             // TableSize muß eine bestimmte Größe haben
  94.                             // um überhaupt eine Partition sein zu können
  95.                             if (de -> de_TableSize >= 16)
  96.                             {
  97.                                 // DosType für die ID kopieren
  98.                                 dostype = de -> de_DosType;
  99.  
  100.                                 // Flag setzen
  101.                                 dostype_bool = TRUE;
  102.                                 goto argh;
  103.                             }
  104.                         }
  105.                     }
  106.                     try_the_other_way = TRUE;
  107.                 }
  108.  
  109.                 argh:
  110.  
  111.                 // DosList wieder freigeben
  112.                 UnLockDosList (LDF_DEVICES | LDF_READ);
  113.  
  114.                 if ((arg . type && dostype_bool) || (arg . type && try_the_other_way))
  115.                 {
  116.                     char buf [5]; // 4 Zeichen + Nullbyte
  117.                     BOOL yes_its_true = TRUE;
  118.  
  119.                     if (try_the_other_way)   // ;-)
  120.                     {
  121.                         // RAM: etc. ...
  122.  
  123.                         BPTR lock = Lock ((STRPTR) arg . name, ACCESS_READ);
  124.                         __aligned struct InfoData info;
  125.  
  126.                         if (Info (lock, &info))
  127.                         {
  128.                             dostype = info.id_DiskType;
  129.                         }
  130.                         else
  131.                         {
  132.                             yes_its_true = FALSE;
  133.                         }
  134.                         UnLock (lock);
  135.                     }
  136.  
  137.  
  138.                     if (yes_its_true)
  139.                     {
  140.                         buf [0] = (dostype >> 24) & 0xff;
  141.                         buf [1] = (dostype >> 16) & 0xff;
  142.                         buf [2] = (dostype >>  8) & 0xff;
  143.                         if  ((dostype & 0xff) < 17)
  144.                         {
  145.                             buf [3] = (dostype & 0xff) + '0';
  146.                         }
  147.                         else
  148.                         {
  149.                             buf [3] = (dostype & 0xff);
  150.                         }
  151.  
  152.                         buf [4] = 0;
  153.  
  154.                         Printf ("%s", buf);
  155.  
  156.                         if (arg . name)
  157.                         {
  158.                             Printf (" ");
  159.                         }
  160.                     }
  161.                 }
  162.  
  163.                 FreeVec (devname);
  164.             }
  165.  
  166.             // ------···------------------···
  167.             // ---···--- Volumename ---···---
  168.             // ···------------------···------
  169.  
  170.             if (arg . name || (! arg . name && ! arg . type))  // Wenn 'NAME' oder kein Argument
  171.             {
  172.                 struct FileLock *lock;
  173.                 struct Process  *myproc;
  174.                 APTR            *old;
  175.  
  176.                 // die Adresse unseres Prozesses holen
  177.                 Forbid();
  178.                 myproc = (struct Process *) FindTask (NULL);
  179.                 Permit();
  180.  
  181.                 if (myproc)
  182.                 {
  183.                     // alten Pointer sichern
  184.                     old = myproc -> pr_WindowPtr;
  185.  
  186.                     // -1 zum Verhindern von Requestern
  187.                     // ("Please insert volume...")
  188.                     myproc -> pr_WindowPtr = (APTR) -1;
  189.                 }
  190.  
  191.                 if (lock = (struct FileLock *) BADDR (Lock (arg . dev, ACCESS_READ)))
  192.                 {
  193.                     char              *volume;
  194.                     struct DeviceList *devlist;
  195.  
  196.                     devlist = (struct DeviceList *) BADDR (lock    -> fl_Volume);
  197.                     volume  = (char *)              BADDR (devlist -> dl_Name);
  198.  
  199.                     Printf ("%s", &volume [1]);
  200.  
  201.                     UnLock (TOBADDR (lock));
  202.                 }
  203.  
  204.                 // Wichtig, restaurieren
  205.                 if (myproc)
  206.                 {
  207.                     myproc -> pr_WindowPtr = old;
  208.                 }
  209.             }
  210.  
  211.             // DosList wieder freigeben
  212.             FreeArgs (rdargs);
  213.         }
  214.         else
  215.         {
  216.             Printf ("Falsche Argumente.\n");
  217.             error = RETURN_FAIL;
  218.         }
  219.  
  220.         // Und die DosLibrary wieder schließen
  221.         CloseLibrary ((struct Library *) DOSBase);
  222.     }
  223.     return (error);
  224. }
  225.